home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / rdma / ib_cm.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  18.2 KB  |  590 lines
  1. /*
  2.  * Copyright (c) 2004, 2005 Intel Corporation.  All rights reserved.
  3.  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
  4.  * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.
  5.  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
  6.  *
  7.  * This software is available to you under a choice of one of two
  8.  * licenses.  You may choose to be licensed under the terms of the GNU
  9.  * General Public License (GPL) Version 2, available from the file
  10.  * COPYING in the main directory of this source tree, or the
  11.  * OpenIB.org BSD license below:
  12.  *
  13.  *     Redistribution and use in source and binary forms, with or
  14.  *     without modification, are permitted provided that the following
  15.  *     conditions are met:
  16.  *
  17.  *      - Redistributions of source code must retain the above
  18.  *        copyright notice, this list of conditions and the following
  19.  *        disclaimer.
  20.  *
  21.  *      - Redistributions in binary form must reproduce the above
  22.  *        copyright notice, this list of conditions and the following
  23.  *        disclaimer in the documentation and/or other materials
  24.  *        provided with the distribution.
  25.  *
  26.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33.  * SOFTWARE.
  34.  */
  35. #if !defined(IB_CM_H)
  36. #define IB_CM_H
  37.  
  38. #include <rdma/ib_mad.h>
  39. #include <rdma/ib_sa.h>
  40.  
  41. enum ib_cm_state {
  42.     IB_CM_IDLE,
  43.     IB_CM_LISTEN,
  44.     IB_CM_REQ_SENT,
  45.     IB_CM_REQ_RCVD,
  46.     IB_CM_MRA_REQ_SENT,
  47.     IB_CM_MRA_REQ_RCVD,
  48.     IB_CM_REP_SENT,
  49.     IB_CM_REP_RCVD,
  50.     IB_CM_MRA_REP_SENT,
  51.     IB_CM_MRA_REP_RCVD,
  52.     IB_CM_ESTABLISHED,
  53.     IB_CM_DREQ_SENT,
  54.     IB_CM_DREQ_RCVD,
  55.     IB_CM_TIMEWAIT,
  56.     IB_CM_SIDR_REQ_SENT,
  57.     IB_CM_SIDR_REQ_RCVD
  58. };
  59.  
  60. enum ib_cm_lap_state {
  61.     IB_CM_LAP_UNINIT,
  62.     IB_CM_LAP_IDLE,
  63.     IB_CM_LAP_SENT,
  64.     IB_CM_LAP_RCVD,
  65.     IB_CM_MRA_LAP_SENT,
  66.     IB_CM_MRA_LAP_RCVD,
  67. };
  68.  
  69. enum ib_cm_event_type {
  70.     IB_CM_REQ_ERROR,
  71.     IB_CM_REQ_RECEIVED,
  72.     IB_CM_REP_ERROR,
  73.     IB_CM_REP_RECEIVED,
  74.     IB_CM_RTU_RECEIVED,
  75.     IB_CM_USER_ESTABLISHED,
  76.     IB_CM_DREQ_ERROR,
  77.     IB_CM_DREQ_RECEIVED,
  78.     IB_CM_DREP_RECEIVED,
  79.     IB_CM_TIMEWAIT_EXIT,
  80.     IB_CM_MRA_RECEIVED,
  81.     IB_CM_REJ_RECEIVED,
  82.     IB_CM_LAP_ERROR,
  83.     IB_CM_LAP_RECEIVED,
  84.     IB_CM_APR_RECEIVED,
  85.     IB_CM_SIDR_REQ_ERROR,
  86.     IB_CM_SIDR_REQ_RECEIVED,
  87.     IB_CM_SIDR_REP_RECEIVED
  88. };
  89.  
  90. enum ib_cm_data_size {
  91.     IB_CM_REQ_PRIVATE_DATA_SIZE     = 92,
  92.     IB_CM_MRA_PRIVATE_DATA_SIZE     = 222,
  93.     IB_CM_REJ_PRIVATE_DATA_SIZE     = 148,
  94.     IB_CM_REP_PRIVATE_DATA_SIZE     = 196,
  95.     IB_CM_RTU_PRIVATE_DATA_SIZE     = 224,
  96.     IB_CM_DREQ_PRIVATE_DATA_SIZE     = 220,
  97.     IB_CM_DREP_PRIVATE_DATA_SIZE     = 224,
  98.     IB_CM_REJ_ARI_LENGTH         = 72,
  99.     IB_CM_LAP_PRIVATE_DATA_SIZE     = 168,
  100.     IB_CM_APR_PRIVATE_DATA_SIZE     = 148,
  101.     IB_CM_APR_INFO_LENGTH         = 72,
  102.     IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE = 216,
  103.     IB_CM_SIDR_REP_PRIVATE_DATA_SIZE = 136,
  104.     IB_CM_SIDR_REP_INFO_LENGTH     = 72,
  105.     IB_CM_COMPARE_SIZE         = 64
  106. };
  107.  
  108. struct ib_cm_id;
  109.  
  110. struct ib_cm_req_event_param {
  111.     struct ib_cm_id        *listen_id;
  112.     u8            port;
  113.  
  114.     struct ib_sa_path_rec    *primary_path;
  115.     struct ib_sa_path_rec    *alternate_path;
  116.  
  117.     __be64            remote_ca_guid;
  118.     u32            remote_qkey;
  119.     u32            remote_qpn;
  120.     enum ib_qp_type        qp_type;
  121.  
  122.     u32            starting_psn;
  123.     u8            responder_resources;
  124.     u8            initiator_depth;
  125.     unsigned int        local_cm_response_timeout:5;
  126.     unsigned int        flow_control:1;
  127.     unsigned int        remote_cm_response_timeout:5;
  128.     unsigned int        retry_count:3;
  129.     unsigned int        rnr_retry_count:3;
  130.     unsigned int        srq:1;
  131. };
  132.  
  133. struct ib_cm_rep_event_param {
  134.     __be64            remote_ca_guid;
  135.     u32            remote_qkey;
  136.     u32            remote_qpn;
  137.     u32            starting_psn;
  138.     u8            responder_resources;
  139.     u8            initiator_depth;
  140.     unsigned int        target_ack_delay:5;
  141.     unsigned int        failover_accepted:2;
  142.     unsigned int        flow_control:1;
  143.     unsigned int        rnr_retry_count:3;
  144.     unsigned int        srq:1;
  145. };
  146.  
  147. enum ib_cm_rej_reason {
  148.     IB_CM_REJ_NO_QP                = 1,
  149.     IB_CM_REJ_NO_EEC            = 2,
  150.     IB_CM_REJ_NO_RESOURCES            = 3,
  151.     IB_CM_REJ_TIMEOUT            = 4,
  152.     IB_CM_REJ_UNSUPPORTED            = 5,
  153.     IB_CM_REJ_INVALID_COMM_ID        = 6,
  154.     IB_CM_REJ_INVALID_COMM_INSTANCE        = 7,
  155.     IB_CM_REJ_INVALID_SERVICE_ID        = 8,
  156.     IB_CM_REJ_INVALID_TRANSPORT_TYPE    = 9,
  157.     IB_CM_REJ_STALE_CONN            = 10,
  158.     IB_CM_REJ_RDC_NOT_EXIST            = 11,
  159.     IB_CM_REJ_INVALID_GID            = 12,
  160.     IB_CM_REJ_INVALID_LID            = 13,
  161.     IB_CM_REJ_INVALID_SL            = 14,
  162.     IB_CM_REJ_INVALID_TRAFFIC_CLASS        = 15,
  163.     IB_CM_REJ_INVALID_HOP_LIMIT        = 16,
  164.     IB_CM_REJ_INVALID_PACKET_RATE        = 17,
  165.     IB_CM_REJ_INVALID_ALT_GID        = 18,
  166.     IB_CM_REJ_INVALID_ALT_LID        = 19,
  167.     IB_CM_REJ_INVALID_ALT_SL        = 20,
  168.     IB_CM_REJ_INVALID_ALT_TRAFFIC_CLASS    = 21,
  169.     IB_CM_REJ_INVALID_ALT_HOP_LIMIT        = 22,
  170.     IB_CM_REJ_INVALID_ALT_PACKET_RATE    = 23,
  171.     IB_CM_REJ_PORT_CM_REDIRECT        = 24,
  172.     IB_CM_REJ_PORT_REDIRECT            = 25,
  173.     IB_CM_REJ_INVALID_MTU            = 26,
  174.     IB_CM_REJ_INSUFFICIENT_RESP_RESOURCES    = 27,
  175.     IB_CM_REJ_CONSUMER_DEFINED        = 28,
  176.     IB_CM_REJ_INVALID_RNR_RETRY        = 29,
  177.     IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID    = 30,
  178.     IB_CM_REJ_INVALID_CLASS_VERSION        = 31,
  179.     IB_CM_REJ_INVALID_FLOW_LABEL        = 32,
  180.     IB_CM_REJ_INVALID_ALT_FLOW_LABEL    = 33
  181. };
  182.  
  183. struct ib_cm_rej_event_param {
  184.     enum ib_cm_rej_reason    reason;
  185.     void            *ari;
  186.     u8            ari_length;
  187. };
  188.  
  189. struct ib_cm_mra_event_param {
  190.     u8    service_timeout;
  191. };
  192.  
  193. struct ib_cm_lap_event_param {
  194.     struct ib_sa_path_rec    *alternate_path;
  195. };
  196.  
  197. enum ib_cm_apr_status {
  198.     IB_CM_APR_SUCCESS,
  199.     IB_CM_APR_INVALID_COMM_ID,
  200.     IB_CM_APR_UNSUPPORTED,
  201.     IB_CM_APR_REJECT,
  202.     IB_CM_APR_REDIRECT,
  203.     IB_CM_APR_IS_CURRENT,
  204.     IB_CM_APR_INVALID_QPN_EECN,
  205.     IB_CM_APR_INVALID_LID,
  206.     IB_CM_APR_INVALID_GID,
  207.     IB_CM_APR_INVALID_FLOW_LABEL,
  208.     IB_CM_APR_INVALID_TCLASS,
  209.     IB_CM_APR_INVALID_HOP_LIMIT,
  210.     IB_CM_APR_INVALID_PACKET_RATE,
  211.     IB_CM_APR_INVALID_SL
  212. };
  213.  
  214. struct ib_cm_apr_event_param {
  215.     enum ib_cm_apr_status    ap_status;
  216.     void            *apr_info;
  217.     u8            info_len;
  218. };
  219.  
  220. struct ib_cm_sidr_req_event_param {
  221.     struct ib_cm_id        *listen_id;
  222.     u8            port;
  223.     u16            pkey;
  224. };
  225.  
  226. enum ib_cm_sidr_status {
  227.     IB_SIDR_SUCCESS,
  228.     IB_SIDR_UNSUPPORTED,
  229.     IB_SIDR_REJECT,
  230.     IB_SIDR_NO_QP,
  231.     IB_SIDR_REDIRECT,
  232.     IB_SIDR_UNSUPPORTED_VERSION
  233. };
  234.  
  235. struct ib_cm_sidr_rep_event_param {
  236.     enum ib_cm_sidr_status    status;
  237.     u32            qkey;
  238.     u32            qpn;
  239.     void            *info;
  240.     u8            info_len;
  241. };
  242.  
  243. struct ib_cm_event {
  244.     enum ib_cm_event_type    event;
  245.     union {
  246.         struct ib_cm_req_event_param    req_rcvd;
  247.         struct ib_cm_rep_event_param    rep_rcvd;
  248.         /* No data for RTU received events. */
  249.         struct ib_cm_rej_event_param    rej_rcvd;
  250.         struct ib_cm_mra_event_param    mra_rcvd;
  251.         struct ib_cm_lap_event_param    lap_rcvd;
  252.         struct ib_cm_apr_event_param    apr_rcvd;
  253.         /* No data for DREQ/DREP received events. */
  254.         struct ib_cm_sidr_req_event_param sidr_req_rcvd;
  255.         struct ib_cm_sidr_rep_event_param sidr_rep_rcvd;
  256.         enum ib_wc_status        send_status;
  257.     } param;
  258.  
  259.     void            *private_data;
  260. };
  261.  
  262. /**
  263.  * ib_cm_handler - User-defined callback to process communication events.
  264.  * @cm_id: Communication identifier associated with the reported event.
  265.  * @event: Information about the communication event.
  266.  *
  267.  * IB_CM_REQ_RECEIVED and IB_CM_SIDR_REQ_RECEIVED communication events
  268.  * generated as a result of listen requests result in the allocation of a
  269.  * new @cm_id.  The new @cm_id is returned to the user through this callback.
  270.  * Clients are responsible for destroying the new @cm_id.  For peer-to-peer
  271.  * IB_CM_REQ_RECEIVED and all other events, the returned @cm_id corresponds
  272.  * to a user's existing communication identifier.
  273.  *
  274.  * Users may not call ib_destroy_cm_id while in the context of this callback;
  275.  * however, returning a non-zero value instructs the communication manager to
  276.  * destroy the @cm_id after the callback completes.
  277.  */
  278. typedef int (*ib_cm_handler)(struct ib_cm_id *cm_id,
  279.                  struct ib_cm_event *event);
  280.  
  281. struct ib_cm_id {
  282.     ib_cm_handler        cm_handler;
  283.     void            *context;
  284.     struct ib_device    *device;
  285.     __be64            service_id;
  286.     __be64            service_mask;
  287.     enum ib_cm_state    state;        /* internal CM/debug use */
  288.     enum ib_cm_lap_state    lap_state;    /* internal CM/debug use */
  289.     __be32            local_id;
  290.     __be32            remote_id;
  291.     u32            remote_cm_qpn;  /* 1 unless redirected */
  292. };
  293.  
  294. /**
  295.  * ib_create_cm_id - Allocate a communication identifier.
  296.  * @device: Device associated with the cm_id.  All related communication will
  297.  * be associated with the specified device.
  298.  * @cm_handler: Callback invoked to notify the user of CM events.
  299.  * @context: User specified context associated with the communication
  300.  *   identifier.
  301.  *
  302.  * Communication identifiers are used to track connection states, service
  303.  * ID resolution requests, and listen requests.
  304.  */
  305. struct ib_cm_id *ib_create_cm_id(struct ib_device *device,
  306.                  ib_cm_handler cm_handler,
  307.                  void *context);
  308.  
  309. /**
  310.  * ib_destroy_cm_id - Destroy a connection identifier.
  311.  * @cm_id: Connection identifier to destroy.
  312.  *
  313.  * This call blocks until the connection identifier is destroyed.
  314.  */
  315. void ib_destroy_cm_id(struct ib_cm_id *cm_id);
  316.  
  317. #define IB_SERVICE_ID_AGN_MASK    __constant_cpu_to_be64(0xFF00000000000000ULL)
  318. #define IB_CM_ASSIGN_SERVICE_ID __constant_cpu_to_be64(0x0200000000000000ULL)
  319. #define IB_CMA_SERVICE_ID    __constant_cpu_to_be64(0x0000000001000000ULL)
  320. #define IB_CMA_SERVICE_ID_MASK    __constant_cpu_to_be64(0xFFFFFFFFFF000000ULL)
  321. #define IB_SDP_SERVICE_ID    __constant_cpu_to_be64(0x0000000000010000ULL)
  322. #define IB_SDP_SERVICE_ID_MASK    __constant_cpu_to_be64(0xFFFFFFFFFFFF0000ULL)
  323.  
  324. struct ib_cm_compare_data {
  325.     u8  data[IB_CM_COMPARE_SIZE];
  326.     u8  mask[IB_CM_COMPARE_SIZE];
  327. };
  328.  
  329. /**
  330.  * ib_cm_listen - Initiates listening on the specified service ID for
  331.  *   connection and service ID resolution requests.
  332.  * @cm_id: Connection identifier associated with the listen request.
  333.  * @service_id: Service identifier matched against incoming connection
  334.  *   and service ID resolution requests.  The service ID should be specified
  335.  *   network-byte order.  If set to IB_CM_ASSIGN_SERVICE_ID, the CM will
  336.  *   assign a service ID to the caller.
  337.  * @service_mask: Mask applied to service ID used to listen across a
  338.  *   range of service IDs.  If set to 0, the service ID is matched
  339.  *   exactly.  This parameter is ignored if %service_id is set to
  340.  *   IB_CM_ASSIGN_SERVICE_ID.
  341.  * @compare_data: This parameter is optional.  It specifies data that must
  342.  *   appear in the private data of a connection request for the specified
  343.  *   listen request.
  344.  */
  345. int ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id, __be64 service_mask,
  346.          struct ib_cm_compare_data *compare_data);
  347.  
  348. struct ib_cm_req_param {
  349.     struct ib_sa_path_rec    *primary_path;
  350.     struct ib_sa_path_rec    *alternate_path;
  351.     __be64            service_id;
  352.     u32            qp_num;
  353.     enum ib_qp_type        qp_type;
  354.     u32            starting_psn;
  355.     const void        *private_data;
  356.     u8            private_data_len;
  357.     u8            peer_to_peer;
  358.     u8            responder_resources;
  359.     u8            initiator_depth;
  360.     u8            remote_cm_response_timeout;
  361.     u8            flow_control;
  362.     u8            local_cm_response_timeout;
  363.     u8            retry_count;
  364.     u8            rnr_retry_count;
  365.     u8            max_cm_retries;
  366.     u8            srq;
  367. };
  368.  
  369. /**
  370.  * ib_send_cm_req - Sends a connection request to the remote node.
  371.  * @cm_id: Connection identifier that will be associated with the
  372.  *   connection request.
  373.  * @param: Connection request information needed to establish the
  374.  *   connection.
  375.  */
  376. int ib_send_cm_req(struct ib_cm_id *cm_id,
  377.            struct ib_cm_req_param *param);
  378.  
  379. struct ib_cm_rep_param {
  380.     u32        qp_num;
  381.     u32        starting_psn;
  382.     const void    *private_data;
  383.     u8        private_data_len;
  384.     u8        responder_resources;
  385.     u8        initiator_depth;
  386.     u8        failover_accepted;
  387.     u8        flow_control;
  388.     u8        rnr_retry_count;
  389.     u8        srq;
  390. };
  391.  
  392. /**
  393.  * ib_send_cm_rep - Sends a connection reply in response to a connection
  394.  *   request.
  395.  * @cm_id: Connection identifier that will be associated with the
  396.  *   connection request.
  397.  * @param: Connection reply information needed to establish the
  398.  *   connection.
  399.  */
  400. int ib_send_cm_rep(struct ib_cm_id *cm_id,
  401.            struct ib_cm_rep_param *param);
  402.  
  403. /**
  404.  * ib_send_cm_rtu - Sends a connection ready to use message in response
  405.  *   to a connection reply message.
  406.  * @cm_id: Connection identifier associated with the connection request.
  407.  * @private_data: Optional user-defined private data sent with the
  408.  *   ready to use message.
  409.  * @private_data_len: Size of the private data buffer, in bytes.
  410.  */
  411. int ib_send_cm_rtu(struct ib_cm_id *cm_id,
  412.            const void *private_data,
  413.            u8 private_data_len);
  414.  
  415. /**
  416.  * ib_send_cm_dreq - Sends a disconnection request for an existing
  417.  *   connection.
  418.  * @cm_id: Connection identifier associated with the connection being
  419.  *   released.
  420.  * @private_data: Optional user-defined private data sent with the
  421.  *   disconnection request message.
  422.  * @private_data_len: Size of the private data buffer, in bytes.
  423.  */
  424. int ib_send_cm_dreq(struct ib_cm_id *cm_id,
  425.             const void *private_data,
  426.             u8 private_data_len);
  427.  
  428. /**
  429.  * ib_send_cm_drep - Sends a disconnection reply to a disconnection request.
  430.  * @cm_id: Connection identifier associated with the connection being
  431.  *   released.
  432.  * @private_data: Optional user-defined private data sent with the
  433.  *   disconnection reply message.
  434.  * @private_data_len: Size of the private data buffer, in bytes.
  435.  *
  436.  * If the cm_id is in the correct state, the CM will transition the connection
  437.  * to the timewait state, even if an error occurs sending the DREP message.
  438.  */
  439. int ib_send_cm_drep(struct ib_cm_id *cm_id,
  440.             const void *private_data,
  441.             u8 private_data_len);
  442.  
  443. /**
  444.  * ib_cm_notify - Notifies the CM of an event reported to the consumer.
  445.  * @cm_id: Connection identifier to transition to established.
  446.  * @event: Type of event.
  447.  *
  448.  * This routine should be invoked by users to notify the CM of relevant
  449.  * communication events.  Events that should be reported to the CM and
  450.  * when to report them are:
  451.  *
  452.  * IB_EVENT_COMM_EST - Used when a message is received on a connected
  453.  *    QP before an RTU has been received.
  454.  * IB_EVENT_PATH_MIG - Notifies the CM that the connection has failed over
  455.  *   to the alternate path.
  456.  */
  457. int ib_cm_notify(struct ib_cm_id *cm_id, enum ib_event_type event);
  458.  
  459. /**
  460.  * ib_send_cm_rej - Sends a connection rejection message to the
  461.  *   remote node.
  462.  * @cm_id: Connection identifier associated with the connection being
  463.  *   rejected.
  464.  * @reason: Reason for the connection request rejection.
  465.  * @ari: Optional additional rejection information.
  466.  * @ari_length: Size of the additional rejection information, in bytes.
  467.  * @private_data: Optional user-defined private data sent with the
  468.  *   rejection message.
  469.  * @private_data_len: Size of the private data buffer, in bytes.
  470.  */
  471. int ib_send_cm_rej(struct ib_cm_id *cm_id,
  472.            enum ib_cm_rej_reason reason,
  473.            void *ari,
  474.            u8 ari_length,
  475.            const void *private_data,
  476.            u8 private_data_len);
  477.  
  478. #define IB_CM_MRA_FLAG_DELAY 0x80  /* Send MRA only after a duplicate msg */
  479.  
  480. /**
  481.  * ib_send_cm_mra - Sends a message receipt acknowledgement to a connection
  482.  *   message.
  483.  * @cm_id: Connection identifier associated with the connection message.
  484.  * @service_timeout: The lower 5-bits specify the maximum time required for
  485.  *   the sender to reply to to the connection message.  The upper 3-bits
  486.  *   specify additional control flags.
  487.  * @private_data: Optional user-defined private data sent with the
  488.  *   message receipt acknowledgement.
  489.  * @private_data_len: Size of the private data buffer, in bytes.
  490.  */
  491. int ib_send_cm_mra(struct ib_cm_id *cm_id,
  492.            u8 service_timeout,
  493.            const void *private_data,
  494.            u8 private_data_len);
  495.  
  496. /**
  497.  * ib_send_cm_lap - Sends a load alternate path request.
  498.  * @cm_id: Connection identifier associated with the load alternate path
  499.  *   message.
  500.  * @alternate_path: A path record that identifies the alternate path to
  501.  *   load.
  502.  * @private_data: Optional user-defined private data sent with the
  503.  *   load alternate path message.
  504.  * @private_data_len: Size of the private data buffer, in bytes.
  505.  */
  506. int ib_send_cm_lap(struct ib_cm_id *cm_id,
  507.            struct ib_sa_path_rec *alternate_path,
  508.            const void *private_data,
  509.            u8 private_data_len);
  510.  
  511. /**
  512.  * ib_cm_init_qp_attr - Initializes the QP attributes for use in transitioning
  513.  *   to a specified QP state.
  514.  * @cm_id: Communication identifier associated with the QP attributes to
  515.  *   initialize.
  516.  * @qp_attr: On input, specifies the desired QP state.  On output, the
  517.  *   mandatory and desired optional attributes will be set in order to
  518.  *   modify the QP to the specified state.
  519.  * @qp_attr_mask: The QP attribute mask that may be used to transition the
  520.  *   QP to the specified state.
  521.  *
  522.  * Users must set the @qp_attr->qp_state to the desired QP state.  This call
  523.  * will set all required attributes for the given transition, along with
  524.  * known optional attributes.  Users may override the attributes returned from
  525.  * this call before calling ib_modify_qp.
  526.  */
  527. int ib_cm_init_qp_attr(struct ib_cm_id *cm_id,
  528.                struct ib_qp_attr *qp_attr,
  529.                int *qp_attr_mask);
  530.  
  531. /**
  532.  * ib_send_cm_apr - Sends an alternate path response message in response to
  533.  *   a load alternate path request.
  534.  * @cm_id: Connection identifier associated with the alternate path response.
  535.  * @status: Reply status sent with the alternate path response.
  536.  * @info: Optional additional information sent with the alternate path
  537.  *   response.
  538.  * @info_length: Size of the additional information, in bytes.
  539.  * @private_data: Optional user-defined private data sent with the
  540.  *   alternate path response message.
  541.  * @private_data_len: Size of the private data buffer, in bytes.
  542.  */
  543. int ib_send_cm_apr(struct ib_cm_id *cm_id,
  544.            enum ib_cm_apr_status status,
  545.            void *info,
  546.            u8 info_length,
  547.            const void *private_data,
  548.            u8 private_data_len);
  549.  
  550. struct ib_cm_sidr_req_param {
  551.     struct ib_sa_path_rec    *path;
  552.     __be64            service_id;
  553.     int            timeout_ms;
  554.     const void        *private_data;
  555.     u8            private_data_len;
  556.     u8            max_cm_retries;
  557. };
  558.  
  559. /**
  560.  * ib_send_cm_sidr_req - Sends a service ID resolution request to the
  561.  *   remote node.
  562.  * @cm_id: Communication identifier that will be associated with the
  563.  *   service ID resolution request.
  564.  * @param: Service ID resolution request information.
  565.  */
  566. int ib_send_cm_sidr_req(struct ib_cm_id *cm_id,
  567.             struct ib_cm_sidr_req_param *param);
  568.  
  569. struct ib_cm_sidr_rep_param {
  570.     u32            qp_num;
  571.     u32            qkey;
  572.     enum ib_cm_sidr_status    status;
  573.     const void        *info;
  574.     u8            info_length;
  575.     const void        *private_data;
  576.     u8            private_data_len;
  577. };
  578.  
  579. /**
  580.  * ib_send_cm_sidr_rep - Sends a service ID resolution reply to the
  581.  *   remote node.
  582.  * @cm_id: Communication identifier associated with the received service ID
  583.  *   resolution request.
  584.  * @param: Service ID resolution reply information.
  585.  */
  586. int ib_send_cm_sidr_rep(struct ib_cm_id *cm_id,
  587.             struct ib_cm_sidr_rep_param *param);
  588.  
  589. #endif /* IB_CM_H */
  590.